package util.util;


import java.lang.reflect.Array;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.util.regex.Pattern.compile;

public class DevComUtil {

    /**
     * 判断是否不为空
     *
     * @param obj 元素
     * @return 是否不为空
     */
    public static boolean notEmpty(Object obj) {
        return !isEmpty(obj);
    }

    /**
     * 判断是否为空
     *
     * @param obj 元素
     * @return 是否为空
     */
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        } else if (obj instanceof Optional) {
            return !((Optional) obj).isPresent();
        } else if (obj instanceof CharSequence) {
            return ((CharSequence) obj).length() == 0;
        } else if (obj.getClass().isArray()) {
            return Array.getLength(obj) == 0;
        } else if (obj instanceof Collection) {
            return ((Collection) obj).isEmpty();
        } else {
            return obj instanceof Map ? ((Map) obj).isEmpty() : false;
        }
    }

    public static String getRootPath() {
        return System.getProperty("user.dir");
    }

    /**
     * 比较两个元素
     *
     * @param o1 元素1
     * @param o2 元素2
     * @return 是否相等
     */
    public static boolean compare2Obj(Object o1, Object o2) {
        boolean flag = false;
        if ((o1 == o2) || (o1 != null && o1.equals(o2))) {
            flag = true;
        }
        return flag;
    }

    /**
     * 通用TTTTTT
     * 判断数组中是否包含某元素
     *
     * @param arr     数组
     * @param element 元素
     * @return
     */
    public static boolean arrContain(Object[] arr, Object element) {
        boolean isContain = false;
        if (!DevComUtil.isEmpty(arr)) {
            for (Object obj : arr) {
                System.out.println(obj);
                if ((obj != null && obj.equals(element)) || obj == element) {
                    isContain = true;
                    break;
                }
            }
        }
        return isContain;
    }

    /**
     * 通用TTTTTT
     * 首字符转换为大写。
     *
     * @param str
     * @return
     */
    public static String upFirst(String str) {
        if (DevComUtil.isEmpty(str)) {
            return "";
        }
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }

    /***
     * 通用TTTTTT
     * 下划线命名转为驼峰命名
     * @param para
     */
    public static String line2Hump(String para) {
        StringBuilder result = new StringBuilder();
        String a[] = para.split("_");
        for (String s : a) {
            if (result.length() == 0) {
                result.append(s.toLowerCase());
            } else {
                result.append(s.substring(0, 1).toUpperCase());
                result.append(s.substring(1).toLowerCase());
            }
        }
        return result.toString();
    }

    /***
     * 通用TTTTTT
     * 下划线命名转为驼峰命名
     * @param para
     */
    public static String line2HumpFristUp(String para) {
        StringBuilder result = new StringBuilder();
        String a[] = para.split("_");
        for (String s : a) {
            result.append(s.substring(0, 1).toUpperCase());
            result.append(s.substring(1).toLowerCase());
        }
        return result.toString();
    }


    /***
     * 通用TTTTTT
     * 下划线命名转为驼峰命名
     * @param para
     */
    public static String fristUp(String para) {
        if (isEmpty(para)) {
            return "";
        }
        return para.substring(0, 1).toUpperCase() + para.substring(1);
    }


    /***
     * 通用TTTTTT
     * 下划线命名转为驼峰命名
     * @param para
     */
    public static String fristLow(String para) {
        if (isEmpty(para)) {
            return "";
        }
        return para.substring(0, 1).toLowerCase() + para.substring(1);
    }

    /***
     * 通用TTTTTT
     * 驼峰命名转为下划线命名
     *
     * @param para
     *        驼峰命名的字符串
     */
    public static String hump2line(String para) {
        StringBuilder sb = new StringBuilder(para);
        int temp = 0;//定位
        for (int i = 1; i < para.length(); i++) {
            if (Character.isUpperCase(para.charAt(i))) {
                sb.insert(i + temp, "_");
                temp += 1;
            }
        }
        return sb.toString().toUpperCase();
    }

    /**
     * 通用TTTTTT
     * 去除字符串中所有的 换行，空格等
     *
     * @param str
     * @return
     */
    public static String replaceBlank(String str) {
        String dest = "";
        if (str != null) {
            Pattern p = compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(str);
            dest = m.replaceAll("");
        }
        return dest;
    }


    /**
     * 通用TTTTTT
     * 数组打印
     *
     * @param s
     */
    public static void printStr(String[] s) {
        if (s == null) {
            System.out.println("数组是空的！！！");
        } else {
            for (int i = 0, n = s.length; i < n; i++) {
                System.out.print(i + ":  " + s[i] + "   ");
                if ((i + 1) % 10 == 0) {
                    System.out.println();
                }
            }
        }
    }

    /**
     * 字符串拆分为集合
     *
     * @param value 字符串
     * @param split 拆分的元素
     * @return 集合
     */
    public static List<String> str2List(String value, String split) {
        if (isEmpty(value)) {
            return new ArrayList<>();
        }
        String[] split1 = value.split(split);
        List<String> list = new ArrayList<>(split1.length);
        for (String s : split1) {
            list.add(s.trim());
        }
        return list;
    }

    /**
     * 字符串拆分为集合-- 默认用换行拆分
     *
     * @param value 字符串
     * @return 集合
     */
    public static List<String> str2List(String value) {
        return str2List(value, "\n");
    }

    /**
     * 反转list中的元素
     *
     * @param old     原来的list
     * @param <T>元素类型
     * @return 新list
     */
    public static <T> List<T> reList(List<T> old) {
        if (isEmpty(old)) {
            return new ArrayList<>();
        }
        int size = old.size();
        List<T> list = new ArrayList<>(size);
        for (int i = size - 1; i >= 0; i--) {
            list.add(old.get(i));
        }
        return list;
    }

    /**
     * 去除字符串前后的空格
     *
     * @param value 字符串
     * @return 去除字符串前后的空格的字符串
     */
    public static String trimStr(String value) {
        if (DevComUtil.isEmpty(value)) {
            return "";
        }
        return value.trim();
    }

    /**
     * 获取Map中的一个值
     *
     * @param map map
     * @param <T> 值
     * @return 值
     */
    public static <K, T> T mapFristList(Map<K, T> map) {
        if (map == null) {
            return null;
        }
        Optional<Map.Entry<K, T>> first = map.entrySet().stream().findFirst();
        return first.map(Map.Entry::getValue).orElse(null);
    }

}
